home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / sphigs / sphigs.lha / SPHIGS / examples / viewing_demo.MAConly / SPHDEMO_struct.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-26  |  8.8 KB  |  337 lines
  1. #include "SPHDEMO.h"
  2. #include "SPHDEMO_struct.h"
  3. #include "SPHDEMO_view.h"
  4.  
  5.  
  6. /* The following two functions use two undocumented SPHIGS routines that
  7.    allow you to enable/disable views without having to unpost/post.
  8.  */
  9.  
  10. void DisplayAllViews (void) {
  11.    SPH_enableView (SIDE_ORTHO_VIEW);
  12.    SPH_enableView (TOP_ORTHO_VIEW);
  13.    SPH_enableView (TEXT_VIEW);
  14.    PartialScreenRenderView ();
  15. }
  16.  
  17. void DisplayOnlyFullRenderView (void) {
  18.    SPH_disableView (SIDE_ORTHO_VIEW);
  19.    SPH_disableView (TOP_ORTHO_VIEW);
  20.    SPH_disableView (TEXT_VIEW);
  21.    FullScreenRenderView ();
  22. }
  23.  
  24.  
  25. void AddChimneyToHouse (int housestruct)
  26. {
  27.    SPH_openStructure (housestruct);
  28.    SPH_executeStructure (CHIMNEY_STRUCT);
  29.    SPH_closeStructure ();
  30. }
  31.  
  32. void TakeChimneyFromHouse (int housestruct)
  33. {
  34.    SPH_openStructure (housestruct);
  35.    SPH_deleteElement ();
  36.    SPH_closeStructure ();
  37. }
  38.  
  39.  
  40. void CreateTextStructure (void)
  41. {
  42.    point textorigin = {0.1, 0.95, 0.5};
  43. #define CarriageReturn   textorigin[Y]-=0.05
  44.    /* SRGP_loadFont (1, "Times.14"); */
  45.    SPH_openStructure (TEXT_STRUCT);
  46.    /* SPH_setTextFont (1); */
  47.    SPH_setTextColor (red);
  48.    SPH_text (textorigin, "Red = View Ref. Point");
  49.    CarriageReturn;
  50.    SPH_setTextColor (orange);
  51.    SPH_text (textorigin, "Orange = Projection Ref. Point");
  52.    CarriageReturn;
  53.    SPH_setTextColor (limegreen);
  54.    SPH_text (textorigin, "Lime = Front Clipping Plane");
  55.    CarriageReturn;
  56.    SPH_setTextColor (forestgreen);
  57.    SPH_text (textorigin, "Forest = Rear Clipping Plane");
  58.    CarriageReturn;
  59.    SPH_closeStructure ();
  60.    SPH_postRoot (TEXT_STRUCT, TEXT_VIEW);
  61. }
  62.  
  63.  
  64.  
  65. void CreateNormalizedHouseStructure (void)
  66. {
  67.    int i;
  68.    point tempv[8];
  69.    
  70.    int faketoparray[] = {1,2,7,6,5,0,1,6};
  71.    int fakesidearray[] = {2,3,8,7,6,1,2,7};
  72.     
  73.    point house_vertices[] = {
  74.        { 0.,10.,0. },
  75.        { 8.,16.,0. },
  76.        { 16.,10.,0. },
  77.        { 16.,0.,0. },    /* Use the SPHIGS "point" data-type! */
  78.        { 0.,0.,0. },
  79.        { 0.,10.,-40. },
  80.        { 8.,16.,-40. },
  81.        { 16.,10.,-40. },
  82.        { 16.,0.,-40. },
  83.        { 0.,0.,-40. }
  84.     };
  85.     
  86.     /* FACETS ARE VERTEX LISTS counter-clockwise from point of view of
  87.        someone OUTSIDE the house. */
  88.     vertex_index house_facets[] = {
  89.        4,3,2,1,0, -1,
  90.        5,6,7,8,9, -1,
  91.        2,7,6,1,   -1,
  92.        2,3,8,7,   -1,
  93.        3,4,9,8,   -1,
  94.        0,5,9,4,   -1,
  95.        0,1,6,5,   -1
  96.     };
  97.  
  98.  
  99.    SPH_openStructure (HOUSE_STRUCT);
  100.    SPH_polyhedron (10, 7, house_vertices, house_facets);
  101.    SPH_closeStructure();
  102.    
  103.    /* Make fake houses (incomplete) for use in wire orthographic depictions */
  104.    for (i=0; i<8; i++)
  105. #ifdef THINK_C
  106.       memcpy(tempv[i], house_vertices[faketoparray[i]], (size_t)sizeof(point)); 
  107. #else
  108.       bcopy (house_vertices[faketoparray[i]], tempv[i], sizeof(point));
  109. #endif
  110.  
  111.    SPH_openStructure (FAKE_HOUSE_TOP_STRUCT);
  112.      SPH_polyLine (8, tempv);
  113.    SPH_closeStructure();
  114.    
  115.    for (i=0; i<8; i++)
  116. #ifdef THINK_C
  117.       memcpy(tempv[i], house_vertices[fakesidearray[i]], (size_t)sizeof(point));
  118. #else
  119.       bcopy (house_vertices[fakesidearray[i]], tempv[i], sizeof(point));   
  120. #endif
  121.  
  122.    SPH_openStructure (FAKE_HOUSE_SIDE_STRUCT);
  123.      SPH_polyLine (8, tempv);
  124.    SPH_closeStructure();
  125. }
  126.  
  127.  
  128. void CreateChimneyStructure ()
  129. {
  130.    matrix mat;
  131.    
  132.    point chim_verts[] = {
  133.       {0.0, 0.0, 0.0},
  134.       {4, 3, 0.0},
  135.       {4, 7, 0.0},
  136.       {0.0, 7, 0.0},
  137.       {0.0, 0.0, -10},
  138.       {4, 3, -10},
  139.       {4, 7, -10},
  140.       {0, 7, -10}
  141.    };
  142.    
  143.    vertex_index chim_facets[] = 
  144.       {0,1,2,3,  -1,
  145.        4,7,6,5,  -1,
  146.        7,4,0,3,  -1,
  147.        1,5,6,2,  -1,
  148.        7,3,2,6,  -1};
  149.        
  150.    SPH_openStructure (CHIMNEY_STRUCT);
  151.    SPH_setInteriorColor (firebrick);
  152.    SPH_translate (0.0,10.0, -30.0, mat); 
  153.    SPH_setModelingTransformation (mat, ASSIGN);
  154.    SPH_polyhedron (8, 5, chim_verts, chim_facets);
  155.    SPH_closeStructure();
  156. }
  157.  
  158.    
  159.  
  160. void CreateAxesStructure ()
  161. {
  162.    point verts[2] = { {0.0,0.0,0.0}, {0.0,0.0,0.0} };
  163.    
  164.    SPH_openStructure (AXES_STRUCT);
  165.       SPH_setLineColor (blue);
  166.       SPH_setLineWidthScaleFactor (2.0);
  167.       SPH_setTextColor (blue);
  168.       
  169.       verts[1][X] = 80.0; SPH_polyLine (2, verts); 
  170.       SPH_text (verts[1], "X"); verts[1][X]=0.0;
  171.       verts[1][Y] = 80.0; SPH_polyLine (2, verts); 
  172.       SPH_text (verts[1], "Y"); verts[1][Y]=0.0;
  173.       verts[1][Z] = 80.0; SPH_polyLine (2, verts); 
  174.       SPH_text (verts[1], "Z"); verts[1][Z]=0.0;
  175.    SPH_closeStructure ();
  176. }
  177.  
  178. extern matrix inverseVO;
  179.  
  180. void CreateCameraStructure ()
  181. {
  182.    vector zerovec={0.0,0.0,0.0};
  183.    double dy, dx, edgex, edgey;
  184.    point p, frontplane[5], backplane[5], edges[2];
  185.    int i;
  186.    
  187.     SPH_openStructure (CAMERA_STRUCT);
  188.     if ((i=SPH_inquireElementPointer()) > 0)
  189.        SPH_deleteElementsInRange (1, i); /*delete all extant*/
  190.  
  191.     /* PLACE AN IMAGE OF THE VRP LOCATION */
  192.     SPH_setMarkerColor (red);
  193.     MAT3mult_vec (p, zerovec, inverseVO);
  194.     SPH_polyMarker (1, &p);
  195.     
  196.     /* PLACE AN IMAGE OF THE PRP LOCATION */
  197.     SPH_setMarkerColor (orange);
  198.     MAT3mult_vec (p, prp1, inverseVO);
  199.     SPH_polyMarker (1, &p);
  200.     
  201.     /* CALCULATE SLOPES OF THE VIEW VOLUME EDGES */
  202.     /* Here, we assume PRP is always (0,0,somethingPositive) */
  203.     /* And, we assume vmin=vmax and umin=umax. */
  204.     if (persptype1 == PERSPECTIVE) {
  205.        dy = vmax1/prp1[Z];
  206.        dx = umax1/prp1[Z];
  207.     }
  208.     else
  209.        dy = dx = 0.0;
  210.     
  211.     /* PLACE LINES FOR THE FRONT AND BACK CLIP PLANES */
  212.     edgex = umax1 + dx*(-fplane1); edgey = vmax1 + dy*(-fplane1);
  213.     MAT3_SET_VEC (frontplane[0], -edgex, +edgey, fplane1);
  214.     MAT3_SET_VEC (frontplane[1], +edgex, +edgey, fplane1);
  215.     MAT3_SET_VEC (frontplane[2], +edgex, -edgey, fplane1);
  216.     MAT3_SET_VEC (frontplane[3], -edgex, -edgey, fplane1);
  217.     edgex = umax1 + dx*(-bplane1); edgey = vmax1 + dy*(-bplane1);
  218.     MAT3_SET_VEC  (backplane[0], -edgex, +edgey, bplane1);
  219.     MAT3_SET_VEC  (backplane[1], +edgex, +edgey, bplane1);
  220.     MAT3_SET_VEC  (backplane[2], +edgex, -edgey, bplane1);
  221.     MAT3_SET_VEC  (backplane[3], -edgex, -edgey, bplane1);
  222.     for (i=0; i<4; i++) {
  223.        MAT3mult_vec (frontplane[i], frontplane[i], inverseVO);
  224.        MAT3mult_vec (backplane[i], backplane[i], inverseVO);
  225.     }
  226.     MAT3_COPY_VEC (frontplane[4], frontplane[0]);
  227.     MAT3_COPY_VEC (backplane[4], backplane[0]);
  228.     SPH_setLineColor (limegreen);
  229.     SPH_setLineWidthScaleFactor (2.0);
  230.     SPH_polyLine (5, frontplane);
  231.     SPH_setLineColor (forestgreen);
  232.     SPH_polyLine (5, backplane);
  233.     for (i=0; i<4; i++) {
  234.        MAT3_COPY_VEC (edges[0], frontplane[i]);
  235.        MAT3_COPY_VEC (edges[1], backplane[i]);
  236.        SPH_polyLine (2, edges);
  237.     }
  238.     SPH_closeStructure ();
  239. }
  240.  
  241.  
  242. void BuildEverything() 
  243. {
  244.    register i;
  245.    matrix temp;
  246.    vector zerovec={0.0,0.0,0.0};
  247.  
  248.    CreateNormalizedHouseStructure();
  249.    CreateAxesStructure();
  250.    CreateTextStructure();
  251.    CreateChimneyStructure();
  252.    
  253.    SPH_openStructure (STREET_STRUCT);
  254.    SPH_setInteriorColor (2);
  255.    SPH_translate (0.0,0.0,0.0, temp);
  256.    SPH_executeStructure (HOUSE_STRUCT);
  257.    SPH_setInteriorColor (4);
  258.    for (i=0; i<5; i++) {
  259.       SPH_setInteriorColor (3+i);
  260.       SPH_translate (20.0,0.0,0.0, temp);
  261.       SPH_setModelingTransformation (temp, PRECONCATENATE);
  262.       SPH_executeStructure (HOUSE_STRUCT);
  263.    }
  264.    SPH_closeStructure();
  265.  
  266.  
  267.    SPH_openStructure (NEIGHBORHOOD_STRUCT);
  268.    SPH_executeStructure (STREET_STRUCT);
  269.    for (i=0; i<2; i++) {
  270.       SPH_translate(0.0,0.0,-70.0, temp);
  271.       SPH_setModelingTransformation (temp, PRECONCATENATE);
  272.       SPH_executeStructure (STREET_STRUCT);
  273.    }
  274.    SPH_closeStructure();
  275.  
  276.  
  277.    SPH_openStructure (FAKE_NEIGHBORHOOD_SIDE_STRUCT);
  278.    SPH_setLineColor (7);
  279.    SPH_executeStructure (FAKE_HOUSE_SIDE_STRUCT);
  280.    for (i=0; i<2; i++) {
  281.       SPH_translate(0.0,0.0,-70.0, temp);
  282.       SPH_setModelingTransformation (temp, PRECONCATENATE);
  283.       SPH_executeStructure (FAKE_HOUSE_SIDE_STRUCT);
  284.    }
  285.    SPH_closeStructure();
  286.    SPH_postRoot (FAKE_NEIGHBORHOOD_SIDE_STRUCT, SIDE_ORTHO_VIEW);
  287.    
  288.    
  289.    SPH_openStructure (FAKE_NEIGHBORHOOD_TOP_STRUCT);
  290.    for (i=0; i<6; i++) {
  291.       int j;
  292.       SPH_setLineColor (i+2);
  293.       for (j=0; j<3; j++) {
  294.          SPH_translate (i*20.0, 0.0,-70.0*j, temp);
  295.          SPH_setModelingTransformation (temp, ASSIGN);
  296.          SPH_executeStructure (FAKE_HOUSE_TOP_STRUCT);
  297.       }
  298.    }
  299.    SPH_closeStructure();
  300.    SPH_postRoot (FAKE_NEIGHBORHOOD_TOP_STRUCT, TOP_ORTHO_VIEW);
  301.  
  302.    SPH_openStructure (GRID_STRUCT);
  303.    {
  304.       register i;
  305.       point p[2];
  306.       
  307.       SPH_setLineColor (yellow);
  308.       
  309.       /* DRAW THE LINES GOING FROM z=10 TO z=(-infinity) */
  310.       MAT3_COPY_VEC (p[0], zerovec);
  311.       MAT3_COPY_VEC (p[1], zerovec);
  312.       p[0][Z] = (double)10;
  313.       p[1][Z] = (double)-200;
  314.       for (i=0; i<=200; i+=20) {
  315.          p[0][X] = p[1][X] = (double)i;
  316.          SPH_polyLine (2, p);
  317.       }
  318.       
  319.       /* DRAW THE LINES GOING FROM x=-10 TO x=infinity */
  320.       MAT3_COPY_VEC (p[0], zerovec);
  321.       MAT3_COPY_VEC (p[1], zerovec);
  322.       p[0][X] = (double)-10;
  323.       p[1][X] = (double)200;
  324.       for (i=0; i<=200; i+=20) {
  325.          p[0][Z] = p[1][Z] = (double)(-i);
  326.          SPH_polyLine (2, p);
  327.       }
  328.    }
  329.    
  330.    SPH_executeStructure (AXES_STRUCT);
  331.    
  332.    SPH_closeStructure ();
  333.  
  334.    SPH_postRoot (CAMERA_STRUCT, TOP_ORTHO_VIEW);
  335.    SPH_postRoot (CAMERA_STRUCT, SIDE_ORTHO_VIEW);
  336. }
  337.